home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / vmed.arc / ED2.CCC < prev    next >
Encoding:
Text File  |  1985-12-03  |  9.4 KB  |  469 lines
  1. /*    Screen editor:    main program module
  2.  *
  3.  *    Module: ed2/ccc
  4.  *    Date: November 14, 1983
  5.  *  Changed: February 29, 1984
  6.  *  Changed: March 8, 1984
  7.  *    Changed: March 10, 1984
  8.  */
  9.  
  10. #include ed0
  11. #include ed1
  12.  
  13. /* the main program dispatches the routines
  14.  * that handle the various modes. */
  15.  
  16. #define    CMNDMODE    1    /* enter command mode flag */
  17. #define    INSMODE        2    /* enter insert mode flag */
  18. #define    EDITMODE    3    /* enter edit mode flag */
  19. #define    EXITMODE    4    /* exit editor flag */
  20.  
  21. main()
  22. {     char    mode;
  23. /* fmt output by default goes to screen */
  24.     fmtassn(NO);
  25. /* set tabs, clear the screen and sign on */
  26.     fmtset(4);
  27.     outclr();
  28.     outxy(14,10);
  29.     fmtsout("VMED 2.2c -- Ed Ream's Editor, PLUS",0);
  30.     outxy(15,12);
  31.     fmtsout("Virtual Memory by Jim Kyle, et al",0);
  32.     outxy(0,1);
  33.     pmtmode("");
  34. /* clear the main buffer */
  35.     name("");    /* clear filename */
  36.     bufnew();
  37.     bufgo(1);
  38. /* start off in command mode */
  39.     mode = CMNDMODE;
  40. /* get null line 1 for edit() */
  41.     edgetln();
  42.     FOREVER {
  43.         if (mode==EXITMODE)
  44.             break;
  45.         switch(mode)    {
  46.             case CMNDMODE:
  47.                 mode = command();
  48.                 break;
  49.             case EDITMODE:
  50.                 mode = edit();
  51.                 break;
  52.             case INSMODE:
  53.                 mode = insert();
  54.                 break;
  55.         }
  56.     }
  57. }
  58.  
  59. /*
  60.  * handle edit mode
  61.  * dispatch the proper routine based on
  62.  * one-character commands
  63.  */
  64. edit()
  65. {     char c;
  66.     int    v;
  67. /* we can't do edgetln() or edgo() here because those
  68.  * calls reset the cursor.
  69.  */
  70.     if (!in_txt())        return(INSMODE);
  71.     pmtedit();
  72.     FOREVER {
  73.         /* get command */
  74.         if ((c=tolower(syscin())) == deletekey)
  75.             c = ZAP1;
  76.         if (c==ESC1)
  77.             return(CMNDMODE);    /* enter command mode */
  78.         else if ((c==INS1)|(c==insertkey))
  79.             return(INSMODE);    /* enter insert mode */
  80.         else if (special(c)==YES)    {
  81.             if (c==UP1 || c==DOWN1)
  82.                 return(INSMODE);
  83.             else
  84.                 continue;
  85.         }
  86.         else if (control(c)==YES)
  87.                 continue;
  88.         else    switch(c)    {
  89. /* remember line number -- added 2/29/84 */
  90.             case recallkey:
  91.                 rememln(bufln());
  92.                 pmtlnx();
  93.                 break;
  94. /* cursor right */
  95.             case crightkey:
  96.                 edright();
  97.                 pmtcol();
  98.                 break;
  99. /* move to bottom of file */
  100.             case bottomkey:
  101.                 edgo(buffree(),0);
  102.                 pmtlnx();
  103.                 break;
  104. /* change one character */
  105.             case changekey:
  106.                 c = syscin();
  107.                 edchng(c);
  108.                 break;
  109. /* move to end of line */
  110.             case endkey:
  111.                 edend();
  112.                 pmtcol();
  113.                 break;
  114. /* find */
  115.             case findkey:
  116.                 edrepl();
  117.                 srch1();
  118.                 pmtmode("edit:");
  119.                 break;
  120. /* goto line number -- changed 2/16/84 */
  121.             case gotokey:
  122.                 v=0;
  123.                 while (isdigit(c=syscin())&&(v<buffree()))
  124.                     v=10*v + (c-'0');
  125.                 if (v)
  126.                     edgo(v,0);
  127.                 else if (c=='r')
  128.                     edgo(rememln(0),0);
  129.                 pmtlnx();
  130.                 break;
  131. /* character change */
  132.             case exchagkey:
  133.                 FOREVER    {
  134.                     c=syscin();
  135.                     if (special(c)==YES || control(c)==YES)
  136.                         break;
  137.                     edchng(c);
  138.                 }
  139.                 break;
  140. /* kill characters */
  141.             case killkey:
  142.                 c=syscin();
  143.                 if ((special(c)==NO)&(control(c)==NO))
  144.                     edkill(c);
  145.                 pmtcol();
  146.                 break;
  147. /* beginning of line */
  148.             case beginkey:
  149.                 edbegin();
  150.                 pmtcol();
  151.                 break;
  152. /* move down one page */
  153.             case pagedown:
  154.                 edgo(bufln()+(SCRNL-2),0);
  155.                 pmtlnx();
  156.                 break;
  157. /* replace a line */
  158.             case replackey:
  159.                 edkill(0xff);
  160.                 return(INSMODE);
  161. /* search for char on line */
  162.             case searchkey:
  163.                 c=syscin();
  164.                 if ((special(c)==NO)&(control(c)==NO))
  165.                     edsrch(c);
  166.                 pmtcol();
  167.                 break;
  168. /* top of file */
  169.             case topkey:
  170.                 edgo(1,0);
  171.                 pmtlnx();
  172.                 break;
  173. /* move up one page */
  174.             case pageup:
  175.                 if(bufln() >= SCRNL)
  176.                     edgo(bufln()-(SCRNL-2),0);
  177.                 else    edgo(1,0);
  178.                 pmtlnx();
  179.                 break;
  180. /* go to end of line and insert */
  181.             case extendkey:
  182.                 edend();
  183.                 return(INSMODE);
  184.         }
  185.         /* do nothing if command not found */
  186.     }
  187. }
  188.  
  189. /* insert mode */
  190. insert()
  191. {    char    c;
  192.     pmtmode("insert:");
  193.     FOREVER {
  194.         /* get command */
  195.         c=syscin();
  196.         if (c==ESC1)
  197.             return(CMNDMODE);    /* enter command mode */
  198.         else if (c==EDIT1)
  199.                 return(EDITMODE);    /* enter edit mode */
  200.         else if (c==INS1);        /* do nothing */
  201.         else if (special(c)==YES)    {
  202.             if (c==UP2 || c==DOWN2)
  203.                 return(EDITMODE);
  204.             else
  205.                 continue;
  206.         }
  207.         else if (control(c)==YES)
  208.                 /* ignore non-special control characters */
  209.                 continue;
  210.         else    {
  211.             /* insert one char in line */
  212.             edins(c);
  213.             pmtcol();
  214.         }
  215.     }
  216. }
  217.  
  218. /* return YES if c is a control char */
  219. control(c)    char    c;
  220. {    if (c==TAB)            return(NO);        /* tab is regular */
  221.     else if (c>=127)    return(YES);    /* del or high bit on */
  222.     else if (c<32)        return(YES);    /* control character */
  223.     else                return(NO);
  224. }
  225.  
  226. /*
  227.  * handle the default actions of all special keys
  228.  * return YES if c is one of the keys
  229.  */
  230. special(c)    char    c;
  231. {     switch(c)    {
  232.         case JOIN1:
  233.             edjoin();
  234.             pmtline();
  235.             return(YES);
  236.         case SPLT1:
  237.             edsplit();
  238.             pmtline();
  239.             return(YES);
  240.         case ABT1:
  241.             edabt();
  242.             pmtcol();
  243.             return(YES);
  244.         case DEL1:
  245.             eddel();
  246.             pmtcol();
  247.             return(YES);
  248.         case ZAP1:
  249.             edzap();
  250.             pmtline();
  251.             return(YES);
  252.         case UP2:
  253.             /* move up */
  254.             edup();
  255.             pmtlnx();
  256.             return(YES);
  257.         case UP1:
  258.             /* insert up */
  259.             ednewup();
  260.             pmtline();
  261.             return(YES);
  262.         case DOWN2:
  263.             /* move down */
  264.             eddn();
  265.             pmtlnx();
  266.             return(YES);
  267.         case DOWN1:
  268.             /* insert down */
  269.             ednewdn();
  270.             pmtline();
  271.             return(YES);
  272.         case LEFT1:
  273.             edleft();
  274.             pmtcol();
  275.             return(YES);
  276.         case RIGHT1:
  277.             edright();
  278.             pmtcol();
  279.             return(YES);
  280.         default:
  281.             return(NO);
  282.     }
  283. }
  284.  
  285. /*
  286.  * command() dispatches command routines while in command mode
  287.  */
  288. command()
  289. {    int    v,topline,ypos,oldline,k;
  290.     char    c,args[SCRNW1],*argp,flag;
  291. /* command mode commands may move the current line.
  292.  * command mode must save the current line on entry
  293.  * and restore it on exit.
  294.  */
  295.     edrepl();
  296. /* remember how the screen was drawn on entry */
  297.     oldline=bufln();
  298.     ypos=outgety();
  299.     topline=oldline-ypos+1;
  300.     flag = 0;
  301.     FOREVER {
  302.         outxy(0,SCRNL1);
  303.         if(flag == 0)
  304.             fmtcrlf();
  305.         flag = 1;
  306.         pmtmode("command:");
  307.         fmtsout(">",0);
  308.         getcmnd(args,1);
  309.         fmtcrlf();
  310.         c=args[0];
  311. /* parse the command given */
  312.         if(c == EOS)
  313.             continue;
  314.         else if ((c==EDIT1)|(c==INS1))     {
  315.             if (oldline==bufln())     {
  316.                 edgetln();
  317.                 bufout(topline,1,SCRNL1);
  318.                 outxy(0,ypos);
  319.             }
  320.             else    edgo(bufln(),0);
  321.             if (c==EDIT1)     return(EDITMODE);
  322.             else            return(INSMODE);
  323.         }
  324.         else if (lookup(args,"append"))    {    /* 2-29-84 */
  325.             append(args);
  326.             bufgo(oldline);
  327.         }
  328.         else if (lookup(args,"paste"))    {
  329.             paste();
  330.             bufgo(oldline);
  331.         }
  332.         else if (lookup(args,"keep") || lookup(args,"hold"))
  333.             keep(args);                        /* 2-29-84 */
  334.         else if (tolower(args[0])=='g')     {
  335.             argp=skipbl(args+1);
  336.             if (argp[0]==EOS)     {
  337.                 edgo(oldline,0);
  338.                 return(EDITMODE);
  339.             }
  340.             else if (number(argp,&v)==YES)     {
  341.                 edgo(v,0);
  342.                 return(EDITMODE);
  343.             }
  344.             else    outm(badnum);
  345.         }
  346.         else if (lookup(args,"line")) {
  347.             argp=skiparg(args);
  348.             argp=skipbl(argp);
  349.             if (argp[0]==EOS)
  350.                 edgo(oldline,0);
  351.             else if (number(argp,&v)==YES) {
  352.                 oldline = v;
  353.                 edgo(v,0);
  354.             }
  355.             else    outm(badnum);
  356.         }
  357.         else if (lookup(args,"put"))
  358.             putfile(args);
  359.         else if (lookup(args,"change"))
  360.             change(args);
  361.         else if (lookup(args,"new"))
  362.             clear();
  363.         else if (lookup(args,"delete")||lookup(args,"del"))
  364.             delete(args);
  365.         else if (lookup(args,"dos")||lookup(args,"quit"))    {
  366.             if(chkbuf()==YES)
  367.                 return(EXITMODE);
  368.         }
  369.         else if (lookup(args,"find"))    {
  370.             if ((k=find()) >= 0)     {
  371.                 edgo(bufln(),k);
  372.                 return(EDITMODE);
  373.             }
  374.             else     {
  375.                 /* get current line */
  376.                 bufgo(oldline);
  377.                 edgetln();                           
  378.                 /* stay in command mode */
  379.                 outm(patnotfnd);
  380.             }
  381.         }
  382.         else if (lookup(args,"list"))
  383.             list(args);
  384.         else if (lookup(args,"print"))     {
  385.             fmtassn(YES);
  386.             list(args);
  387.             fmtassn(NO);
  388.         }
  389.         else if (lookup(args,"load"))     {
  390.             if(load(args) == YES)     {
  391.                 edgo(0,0);
  392.                 return(EDITMODE);
  393.             }
  394.         }
  395.         else if (lookup(args,"name"))
  396.             name(args);
  397.         else if (lookup(args,"save"))
  398.             save(args);
  399.         else if (lookup(args,"search"))
  400.             search(args);
  401.         else if (lookup(args,"tab"))
  402.             tabs(args);
  403.         else if (lookup(args,"copy"))
  404.             copy(args,NO);
  405.         else if (lookup(args,"move"))
  406.             copy(args,YES);
  407.         else if (lookup(args,"top")) {
  408.             edgo(1,0);
  409.             return(EDITMODE);
  410.         }
  411.         else if (lookup(args,"bottom"))     {
  412.             edgo(HUGE,0);
  413.             return(EDITMODE);
  414.         }
  415.         else
  416.             outm(cmdfnd);
  417.     }
  418. }
  419.         
  420. /* return YES if line starts with command */
  421. lookup(line,command)    char    *line,*command;
  422. {     skipbl(line);
  423.     while(*command)
  424.         if (tolower(*line++)!=*command++)
  425.             return(NO);
  426.     if ((*line==EOS)||(*line==' ')||(*line==TAB))
  427.         return(YES);
  428.     else    return(NO);
  429. }
  430.  
  431. /* get next command into argument buffer */
  432. getcmnd(args,offset)    char    *args,offset;
  433. {     char    c,j,k;
  434.     outxy(offset,outgety());
  435.     outdeol();
  436.     k=0;
  437.     while ((c=syscin())!=CR) {
  438.         if ((c==EDIT1)|(c==INS1)) {
  439.             *args=c;
  440.             return;
  441.          }
  442.         if ((c==DEL1)|(c==LEFT1)) {
  443.             if (k>0) {
  444.                 outxy(offset,outgety());
  445.                 outdeol();
  446.                 --k;
  447.                 j=0;
  448.                 while (j<k)
  449.                     outchar(args[j++]);
  450.             }
  451.         }
  452.         else if (c==ABT1) {
  453.             outxy(offset,outgety());
  454.             outdeol();
  455.             k=0;
  456.         }
  457.         else if ((c != TAB) & (c < ' '))
  458.             continue;    /* do nothing */
  459.         else if ((k + offset) < SCRNW1)     {
  460.             args[k++]=c;
  461.             outchar(c);
  462.         }
  463.     }
  464.     args[k]=EOS;
  465. }
  466.  
  467. /* end module ed2/ccc */
  468.  
  469.